namespace System
{
	using System;
	using System.Runtime.CompilerServices;
	using System.Html;
	using System.Collections;
	
	
	/// <summary>
	/// The date parsing and formatting syntax contains a subset of
	/// PHP&apos;s date() function, and the formats that are
	/// supported will provide results equivalent to their PHP versions.
	///
	/// The following is a list of all currently supported formats:
	/// 
	/// Format Description Example returned values
	/// ------ ----------------------------------------------------------------------- -----------------------
	/// d Day of the month, 2 digits with leading zeros 01 to 31
	/// D A short textual representation of the day of the week Mon to Sun
	/// j Day of the month without leading zeros 1 to 31
	/// l A full textual representation of the day of the week Sunday to Saturday
	/// N ISO-8601 numeric representation of the day of the week 1 (for Monday) through 7 (for Sunday)
	/// S English ordinal suffix for the day of the month, 2 characters st, nd, rd or th. Works well with j
	/// w Numeric representation of the day of the week 0 (for Sunday) to 6 (for Saturday)
	/// z The day of the year (starting from 0) 0 to 364 (365 in leap years)
	/// W...
	/// </summary>
	/// <htmlSummary>
	/// The date parsing and formatting syntax contains a subset of
	/// &lt;a href=&quot;http://www.php.net/date&quot;&gt;PHP&apos;s date() function&lt;/a&gt;, and the formats that are
	/// supported will provide results equivalent to their PHP versions.
	///
	/// The following is a list of all currently supported formats:
	/// &lt;pre&gt;
	/// Format Description Example returned values
	/// ------ ----------------------------------------------------------------------- -----------------------
	/// d Day of the month, 2 digits with leading zeros 01 to 31
	/// D A short textual representation of the day of the week Mon to Sun
	/// j Day of the month without leading zeros 1 to 31
	/// l A full textual representation of the day of the week Sunday to Saturday
	/// N ISO-8601 numeric representation of the day of the week 1 (for Monday) through 7 (for Sunday)
	/// S English ordinal suffix for the day of the month, 2 characters st, nd, rd or th. Works well with j
	/// w Numeric representation of the day of the week 0 (for Sunday) to 6 (for Saturday)
	/// z The day of the year (starting from 0) 0 to 364 (365 in leap years)
	/// W ISO-8601 week number of year, weeks starting on Monday 01 to 53
	/// F A full textual representation of a month, such as January or March January to December
	/// m Numeric representation of a month, with leading zeros 01 to 12
	/// M A short textual representation of a month Jan to Dec
	/// n Numeric representation of a month, without leading zeros 1 to 12
	/// t Number of days in the given month 28 to 31
	/// L Whether it&apos;s a leap year 1 if it is a leap year, 0 otherwise.
	/// o ISO-8601 year number (identical to (Y), but if the ISO week number (W) Examples: 1998 or 2004
	/// belongs to the previous or next year, that year is used instead)
	/// Y A full numeric representation of a year, 4 digits Examples: 1999 or 2003
	/// y A two digit representation of a year Examples: 99 or 03
	/// a Lowercase Ante meridiem and Post meridiem am or pm
	/// A Uppercase Ante meridiem and Post meridiem AM or PM
	/// g 12-hour format of an hour without leading zeros 1 to 12
	/// G 24-hour format of an hour without leading zeros 0 to 23
	/// h 12-hour format of an hour with leading zeros 01 to 12
	/// H 24-hour format of an hour with leading zeros 00 to 23
	/// i Minutes, with leading zeros 00 to 59
	/// s Seconds, with leading zeros 00 to 59
	/// u Decimal fraction of a second Examples:
	/// (minimum 1 digit, arbitrary number of digits allowed) 001 (i.e. 0.001s) or
	/// 100 (i.e. 0.100s) or
	/// 999 (i.e. 0.999s) or
	/// 999876543210 (i.e. 0.999876543210s)
	/// O Difference to Greenwich time (GMT) in hours and minutes Example: +1030
	/// P Difference to Greenwich time (GMT) with colon between hours and minutes Example: -08:00
	/// T Timezone abbreviation of the machine running the code Examples: EST, MDT, PDT ...
	/// Z Timezone offset in seconds (negative if west of UTC, positive if east) -43200 to 50400
	/// c ISO 8601 date
	/// Notes: Examples:
	/// 1) If unspecified, the month / day defaults to the current month / day, 1991 or
	/// the time defaults to midnight, while the timezone defaults to the 1992-10 or
	/// browser&apos;s timezone. If a time is specified, it must include both hours 1993-09-20 or
	/// and minutes. The &quot;T&quot; delimiter, seconds, milliseconds and timezone 1994-08-19T16:20+01:00 or
	/// are optional. 1995-07-18T17:21:28-02:00 or
	/// 2) The decimal fraction of a second, if specified, must contain at 1996-06-17T18:22:29.98765+03:00 or
	/// least 1 digit (there is no limit to the maximum number 1997-05-16T19:23:30,12345-0400 or
	/// of digits allowed), and may be delimited by either a &apos;.&apos; or a &apos;,&apos; 1998-04-15T20:24:31.2468Z or
	/// Refer to the examples on the right for the various levels of 1999-03-14T20:24:32Z or
	/// date-time granularity which are supported, or see 2000-02-13T21:25:33
	/// http://www.w3.org/TR/NOTE-datetime for more info. 2001-01-12 22:26:34
	/// U Seconds since the Unix Epoch (January 1 1970 00:00:00 GMT) 1193432466 or -2138434463
	/// M$ Microsoft AJAX serialized dates \/Date(1238606590509)\/ (i.e. UTC milliseconds since epoch) or
	/// \/Date(1238606590509+0800)\/
	/// &lt;/pre&gt;
	///
	/// Example usage (note that you must escape format specifiers with &apos;\\&apos; to render them as character literals):
	/// &lt;pre&gt;&lt;code&gt;
	/// // Sample date:
	/// // &apos;Wed Jan 10 2007 15:05:01 GMT-0600 (Central Standard Time)&apos;
	///
	/// var dt = new Date(&apos;1/10/2007 03:05:01 PM GMT-0600&apos;);
	/// document.write(dt.format(&apos;Y-m-d&apos;)); // 2007-01-10
	/// document.write(dt.format(&apos;F j, Y, g:i a&apos;)); // January 10, 2007, 3:05 pm
	/// document.write(dt.format(&apos;l, \\t\\he jS \\of F Y h:i:s A&apos;)); // Wednesday, the 10th of January 2007 03:05:01 PM
	/// &lt;/code&gt;&lt;/pre&gt;
	///
	/// Here are some standard date/time patterns that you might find helpful. They
	/// are not part of the source of Date.js, but to use them you can simply copy this
	/// block of code into any script that is included after Date.js and they will also become
	/// globally available on the Date object. Feel free to add or remove patterns as needed in your code.
	/// &lt;pre&gt;&lt;code&gt;
	/// Date.patterns = {
	/// ISO8601Long:&quot;Y-m-d H:i:s&quot;,
	/// ISO8601Short:&quot;Y-m-d&quot;,
	/// ShortDate: &quot;n/j/Y&quot;,
	/// LongDate: &quot;l, F d, Y&quot;,
	/// FullDateTime: &quot;l, F d, Y g:i:s A&quot;,
	/// MonthDay: &quot;F d&quot;,
	/// ShortTime: &quot;g:i A&quot;,
	/// LongTime: &quot;g:i:s A&quot;,
	/// SortableDateTime: &quot;Y-m-d\\TH:i:s&quot;,
	/// UniversalSortableDateTime: &quot;Y-m-d H:i:sO&quot;,
	/// YearMonth: &quot;F, Y&quot;
	/// };
	/// &lt;/code&gt;&lt;/pre&gt;
	///
	/// Example usage:
	/// &lt;pre&gt;&lt;code&gt;
	/// var dt = new Date();
	/// document.write(dt.format(Date.patterns.ShortDate));
	/// &lt;/code&gt;&lt;/pre&gt;
	/// &lt;p&gt;Developer-written, custom formats may be used by supplying both a formatting and a parsing function
	/// which perform to specialized requirements. The functions are stored in {@link #parseFunctions} and {@link #formatFunctions}.&lt;/p&gt;
	/// </htmlSummary>
	/// <definedin>src\util\Date.js</definedin>
	[ScriptName("Date")]
	[IgnoreNamespace()]
	[Imported()]
	public sealed partial class DateTimeExtensions
	{
		
		#region Snippets
		public static implicit operator System.DateTime (DateTimeExtensions thisObject)
		{
				throw new System.Exception ("Imported - Not Implemented");
		}
		
		public static implicit operator DateTimeExtensions (System.DateTime otherObject)
		{
				throw new System.Exception ("Imported - Not Implemented");
		}
		#endregion
		
		#region Constructors
		private DateTimeExtensions()
		{
		}
		#endregion
		
		#region Properties
		/// <summary>
		/// Global flag which determines if strict date parsing should be used.
		/// Strict date parsing will not roll-over invalid dates, which is the
		/// default behaviour of javascript Date objects.
		/// (see {@link #parseDate} for more information)
		/// Defaults to false.
		/// </summary>
		/// <htmlSummary>
		/// Global flag which determines if strict date parsing should be used.
		/// Strict date parsing will not roll-over invalid dates, which is the
		/// default behaviour of javascript Date objects.
		/// (see {@link #parseDate} for more information)
		/// Defaults to &lt;tt&gt;false&lt;/tt&gt;.
		/// </htmlSummary>
		/// <definedin>src\util\Date.js</definedin>
		[ScriptName("useStrict")]
		[IntrinsicProperty()]
		public static bool UseStrict
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>
		/// An object hash in which each property is a date parsing function. The property name is the
		/// format string which that function parses.  This object is automatically populated with date parsing functions as
		/// date formats are requested for Ext standard formatting strings.  Custom parsing functions may be inserted into this object, keyed by a name which from then on
		/// may be used as a format string to {@link #parseDate}.  Example:  
		/// Date.parseFunctions[&apos;x-date-format&apos;] = myDateParser;
		///  A parsing function should return a Date object, and is passed the following parameters:   date : String The date string to parse.   strict : Boolean True to validate date strings while parsing
		/// (i.e. prevent javascript Date &quot;rollover&quot;) (The default must be false).
		/// Invalid date strings should return null when parsed.      To enable Dates to also be formatted according to that format, a corresponding
		/// formatting function must be placed into the {@link #formatFunctions} property.
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;An object hash in which each property is a date parsing function. The property name is the
		/// format string which that function parses.&lt;/p&gt;
		/// &lt;p&gt;This object is automatically populated with date parsing functions as
		/// date formats are requested for Ext standard formatting strings.&lt;/p&gt;
		/// &lt;p&gt;Custom parsing functions may be inserted into this object, keyed by a name which from then on
		/// may be used as a format string to {@link #parseDate}.&lt;p&gt;
		/// &lt;p&gt;Example:&lt;/p&gt;&lt;pre&gt;&lt;code&gt;
		/// Date.parseFunctions[&apos;x-date-format&apos;] = myDateParser;
		/// &lt;/code&gt;&lt;/pre&gt;
		/// &lt;p&gt;A parsing function should return a Date object, and is passed the following parameters:&lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
		/// &lt;li&gt;&lt;code&gt;date&lt;/code&gt; : String&lt;div class=&quot;sub-desc&quot;&gt;The date string to parse.&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;code&gt;strict&lt;/code&gt; : Boolean&lt;div class=&quot;sub-desc&quot;&gt;True to validate date strings while parsing
		/// (i.e. prevent javascript Date &quot;rollover&quot;) (The default must be false).
		/// Invalid date strings should return null when parsed.&lt;/div&gt;&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;&lt;/p&gt;
		/// &lt;p&gt;To enable Dates to also be &lt;i&gt;formatted&lt;/i&gt; according to that format, a corresponding
		/// formatting function must be placed into the {@link #formatFunctions} property.
		/// </htmlSummary>
		/// <definedin>src\util\Date.js</definedin>
		[ScriptName("parseFunctions")]
		[IntrinsicProperty()]
		public static object ParseFunctions
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>
		/// An object hash in which each property is a date formatting function. The property name is the
		/// format string which corresponds to the produced formatted date string.  This object is automatically populated with date formatting functions as
		/// date formats are requested for Ext standard formatting strings.  Custom formatting functions may be inserted into this object, keyed by a name which from then on
		/// may be used as a format string to {@link #format}. Example:  
		/// Date.formatFunctions[&apos;x-date-format&apos;] = myDateFormatter;
		///  A formatting function should return a string representation of the passed Date object, and is passed the following parameters:   date : Date The Date to format.      To enable date strings to also be parsed according to that format, a corresponding
		/// parsing function must be placed into the {@link #parseFunctions} property.
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;An object hash in which each property is a date formatting function. The property name is the
		/// format string which corresponds to the produced formatted date string.&lt;/p&gt;
		/// &lt;p&gt;This object is automatically populated with date formatting functions as
		/// date formats are requested for Ext standard formatting strings.&lt;/p&gt;
		/// &lt;p&gt;Custom formatting functions may be inserted into this object, keyed by a name which from then on
		/// may be used as a format string to {@link #format}. Example:&lt;/p&gt;&lt;pre&gt;&lt;code&gt;
		/// Date.formatFunctions[&apos;x-date-format&apos;] = myDateFormatter;
		/// &lt;/code&gt;&lt;/pre&gt;
		/// &lt;p&gt;A formatting function should return a string representation of the passed Date object, and is passed the following parameters:&lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
		/// &lt;li&gt;&lt;code&gt;date&lt;/code&gt; : Date&lt;div class=&quot;sub-desc&quot;&gt;The Date to format.&lt;/div&gt;&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;&lt;/p&gt;
		/// &lt;p&gt;To enable date strings to also be &lt;i&gt;parsed&lt;/i&gt; according to that format, a corresponding
		/// parsing function must be placed into the {@link #parseFunctions} property.
		/// </htmlSummary>
		/// <definedin>src\util\Date.js</definedin>
		[ScriptName("formatFunctions")]
		[IntrinsicProperty()]
		public static object FormatFunctions
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>Date interval constant</summary>
		/// <definedin>src\util\Date.js</definedin>
		[ScriptName("MILLI")]
		[IntrinsicProperty()]
		public static string MILLI
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
		}
		
		/// <summary>Date interval constant</summary>
		/// <definedin>src\util\Date.js</definedin>
		[ScriptName("SECOND")]
		[IntrinsicProperty()]
		public static string SECOND
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
		}
		
		/// <summary>Date interval constant</summary>
		/// <definedin>src\util\Date.js</definedin>
		[ScriptName("MINUTE")]
		[IntrinsicProperty()]
		public static string MINUTE
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
		}
		
		/// <summary>Date interval constant</summary>
		/// <definedin>src\util\Date.js</definedin>
		[ScriptName("HOUR")]
		[IntrinsicProperty()]
		public static string HOUR
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
		}
		
		/// <summary>Date interval constant</summary>
		/// <definedin>src\util\Date.js</definedin>
		[ScriptName("DAY")]
		[IntrinsicProperty()]
		public static string DAY
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
		}
		
		/// <summary>Date interval constant</summary>
		/// <definedin>src\util\Date.js</definedin>
		[ScriptName("MONTH")]
		[IntrinsicProperty()]
		public static string MONTH
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
		}
		
		/// <summary>Date interval constant</summary>
		/// <definedin>src\util\Date.js</definedin>
		[ScriptName("YEAR")]
		[IntrinsicProperty()]
		public static string YEAR
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
		}
		
		/// <summary>
		/// An object hash containing default date values used during date parsing.  The following properties are available:   y : Number The default year value. (defaults to undefined)   m : Number The default 1-based month value. (defaults to undefined)   d : Number The default day value. (defaults to undefined)   h : Number The default hour value. (defaults to undefined)   i : Number The default minute value. (defaults to undefined)   s : Number The default second value. (defaults to undefined)   ms : Number The default millisecond value. (defaults to undefined)      Override these properties to customize the default date values used by the {@link #parseDate} method.  Note: In countries which experience Daylight Saving Time (i.e. DST), the h, i, s
		/// and ms properties may coincide with the exact time in which DST takes effect.
		/// It is the responsiblity of the developer to account for this. 
		/// Example Usage:
		/// 
		/// // set default day value to the first day of the month
		/// Date.defaults.d = 1;
		///
		/// //...
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;An object hash containing default date values used during date parsing.&lt;/p&gt;
		/// &lt;p&gt;The following properties are available:&lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
		/// &lt;li&gt;&lt;code&gt;y&lt;/code&gt; : Number&lt;div class=&quot;sub-desc&quot;&gt;The default year value. (defaults to undefined)&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;code&gt;m&lt;/code&gt; : Number&lt;div class=&quot;sub-desc&quot;&gt;The default 1-based month value. (defaults to undefined)&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;code&gt;d&lt;/code&gt; : Number&lt;div class=&quot;sub-desc&quot;&gt;The default day value. (defaults to undefined)&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;code&gt;h&lt;/code&gt; : Number&lt;div class=&quot;sub-desc&quot;&gt;The default hour value. (defaults to undefined)&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;code&gt;i&lt;/code&gt; : Number&lt;div class=&quot;sub-desc&quot;&gt;The default minute value. (defaults to undefined)&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;code&gt;s&lt;/code&gt; : Number&lt;div class=&quot;sub-desc&quot;&gt;The default second value. (defaults to undefined)&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;code&gt;ms&lt;/code&gt; : Number&lt;div class=&quot;sub-desc&quot;&gt;The default millisecond value. (defaults to undefined)&lt;/div&gt;&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;&lt;/p&gt;
		/// &lt;p&gt;Override these properties to customize the default date values used by the {@link #parseDate} method.&lt;/p&gt;
		/// &lt;p&gt;&lt;b&gt;Note: In countries which experience Daylight Saving Time (i.e. DST), the &lt;tt&gt;h&lt;/tt&gt;, &lt;tt&gt;i&lt;/tt&gt;, &lt;tt&gt;s&lt;/tt&gt;
		/// and &lt;tt&gt;ms&lt;/tt&gt; properties may coincide with the exact time in which DST takes effect.
		/// It is the responsiblity of the developer to account for this.&lt;/b&gt;&lt;/p&gt;
		/// Example Usage:
		/// &lt;pre&gt;&lt;code&gt;
		/// // set default day value to the first day of the month
		/// Date.defaults.d = 1;
		///
		/// // parse a February date string containing only year and month values.
		/// // setting the default day value to 1 prevents weird date rollover issues
		/// // when attempting to parse the following date string on, for example, March 31st 2009.
		/// Date.parseDate(&apos;2009-02&apos;, &apos;Y-m&apos;); // returns a Date object representing February 1st 2009
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\util\Date.js</definedin>
		[ScriptName("defaults")]
		[IntrinsicProperty()]
		public static object Defaults
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>
		/// An array of textual day names.
		/// Override these values for international dates.
		/// Example:
		/// 
		/// Date.dayNames = [
		/// &apos;SundayInYourLang&apos;,
		/// &apos;MondayInYourLang&apos;,
		/// ...
		/// ];
		/// </summary>
		/// <htmlSummary>
		/// An array of textual day names.
		/// Override these values for international dates.
		/// Example:
		/// &lt;pre&gt;&lt;code&gt;
		/// Date.dayNames = [
		/// &apos;SundayInYourLang&apos;,
		/// &apos;MondayInYourLang&apos;,
		/// ...
		/// ];
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\util\Date.js</definedin>
		[ScriptName("dayNames")]
		[IntrinsicProperty()]
		public static System.Array DayNames
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>
		/// An array of textual month names.
		/// Override these values for international dates.
		/// Example:
		/// 
		/// Date.monthNames = [
		/// &apos;JanInYourLang&apos;,
		/// &apos;FebInYourLang&apos;,
		/// ...
		/// ];
		/// </summary>
		/// <htmlSummary>
		/// An array of textual month names.
		/// Override these values for international dates.
		/// Example:
		/// &lt;pre&gt;&lt;code&gt;
		/// Date.monthNames = [
		/// &apos;JanInYourLang&apos;,
		/// &apos;FebInYourLang&apos;,
		/// ...
		/// ];
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\util\Date.js</definedin>
		[ScriptName("monthNames")]
		[IntrinsicProperty()]
		public static System.Array MonthNames
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>
		/// An object hash of zero-based javascript month numbers (with short month names as keys. note: keys are case-sensitive).
		/// Override these values for international dates.
		/// Example:
		/// 
		/// Date.monthNumbers = {
		/// &apos;ShortJanNameInYourLang&apos;:0,
		/// &apos;ShortFebNameInYourLang&apos;:1,
		/// ...
		/// };
		/// </summary>
		/// <htmlSummary>
		/// An object hash of zero-based javascript month numbers (with short month names as keys. note: keys are case-sensitive).
		/// Override these values for international dates.
		/// Example:
		/// &lt;pre&gt;&lt;code&gt;
		/// Date.monthNumbers = {
		/// &apos;ShortJanNameInYourLang&apos;:0,
		/// &apos;ShortFebNameInYourLang&apos;:1,
		/// ...
		/// };
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\util\Date.js</definedin>
		[ScriptName("monthNumbers")]
		[IntrinsicProperty()]
		public static object MonthNumbers
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>
		/// The base format-code to formatting-function hashmap used by the {@link #format} method.
		/// Formatting functions are strings (or functions which return strings) which
		/// will return the appropriate value when evaluated in the context of the Date object
		/// from which the {@link #format} method is called.
		/// Add to / override these mappings for custom date formatting.
		/// Note: Date.format() treats characters as literals if an appropriate mapping cannot be found.
		/// Example:
		/// 
		/// Date.formatCodes.x = &quot;String.leftPad(this.getDate(), 2, &apos;0&apos;)&quot;;
		/// (new Date()).format(&quot;X&quot;); // returns the current day of the month
		/// </summary>
		/// <htmlSummary>
		/// The base format-code to formatting-function hashmap used by the {@link #format} method.
		/// Formatting functions are strings (or functions which return strings) which
		/// will return the appropriate value when evaluated in the context of the Date object
		/// from which the {@link #format} method is called.
		/// Add to / override these mappings for custom date formatting.
		/// Note: Date.format() treats characters as literals if an appropriate mapping cannot be found.
		/// Example:
		/// &lt;pre&gt;&lt;code&gt;
		/// Date.formatCodes.x = &quot;String.leftPad(this.getDate(), 2, &apos;0&apos;)&quot;;
		/// (new Date()).format(&quot;X&quot;); // returns the current day of the month
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\util\Date.js</definedin>
		[ScriptName("formatCodes")]
		[IntrinsicProperty()]
		public static object FormatCodes
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		#endregion
		
		#region Methods
		/// <summary>
		/// Get the short month name for the given month number.
		/// Override this function for international dates.
		/// </summary>
		/// <definedin>src\util\Date.js</definedin>
		/// <param name="month">A zero-based javascript month number.</param>
		/// <returns>The short month name.</returns>
		[ScriptName("getShortMonthName")]
		public static string GetShortMonthName(System.Number month)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Get the short day name for the given day number.
		/// Override this function for international dates.
		/// </summary>
		/// <definedin>src\util\Date.js</definedin>
		/// <param name="day">A zero-based javascript day number.</param>
		/// <returns>The short day name.</returns>
		[ScriptName("getShortDayName")]
		public static string GetShortDayName(System.Number day)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Get the zero-based javascript month number for the given short/full month name.
		/// Override this function for international dates.
		/// </summary>
		/// <definedin>src\util\Date.js</definedin>
		/// <param name="name">The short/full month name.</param>
		/// <returns>The zero-based javascript month number.</returns>
		[ScriptName("getMonthNumber")]
		public static System.Number GetMonthNumber(string name)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// In the am/pm parsing routines, we allow both upper and lower case
		/// even though it doesn&apos;t exactly match the spec. It gives much more flexibility
		/// in being able to specify case insensitive regexes.
		/// </summary>
		/// <definedin>src\util\Date.js</definedin>
		[ScriptName("a")]
		public void A()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Get the timezone abbreviation of the current date (equivalent to the format specifier &apos;T&apos;).
		///
		/// Note: The date string returned by the javascript Date object&apos;s toString() method varies
		/// between browsers (e.g. FF vs IE) and system region settings (e.g. IE in Asia vs IE in America).
		/// For a given date string e.g. &quot;Thu Oct 25 2007 22:55:35 GMT+0800 (Malay Peninsula Standard Time)&quot;,
		/// getTimezone() first tries to get the timezone abbreviation from between a pair of parentheses
		/// (which may or may not be present), failing which it proceeds to get the timezone abbreviation
		/// from the GMT offset portion of the date string.
		/// </summary>
		/// <definedin>src\util\Date.js</definedin>
		/// <returns>The abbreviated timezone name (e.g. &apos;CST&apos;, &apos;PDT&apos;, &apos;EDT&apos;, &apos;MPST&apos; ...).</returns>
		[ScriptName("getTimezone")]
		public string GetTimezone()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Get the numeric day number of the year, adjusted for leap year.</summary>
		/// <definedin>src\util\Date.js</definedin>
		/// <returns>0 to 364 (365 in leap years).</returns>
		[ScriptName("getDayOfYear")]
		public System.Number GetDayOfYear()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Get the numeric ISO-8601 week number of the year.
		/// (equivalent to the format specifier &apos;W&apos;, but without a leading zero).
		/// </summary>
		/// <definedin>src\util\Date.js</definedin>
		/// <returns>1 to 53</returns>
		[ScriptName("getWeekOfYear")]
		public System.Number GetWeekOfYear()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Checks if the current date falls within a leap year.</summary>
		/// <definedin>src\util\Date.js</definedin>
		/// <returns>True if the current date falls within a leap year, false otherwise.</returns>
		[ScriptName("isLeapYear")]
		public bool IsLeapYear()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Get the first day of the current month, adjusted for leap year. The returned value
		/// is the numeric day index within the week (0-6) which can be used in conjunction with
		/// the {@link #monthNames} array to retrieve the textual day name.
		/// Example:
		/// 
		/// var dt = new Date(&apos;1/10/2007&apos;);
		/// document.write(Date.dayNames[dt.getFirstDayOfMonth()]); //output: &apos;Monday&apos;
		/// </summary>
		/// <htmlSummary>
		/// Get the first day of the current month, adjusted for leap year. The returned value
		/// is the numeric day index within the week (0-6) which can be used in conjunction with
		/// the {@link #monthNames} array to retrieve the textual day name.
		/// Example:
		/// &lt;pre&gt;&lt;code&gt;
		/// var dt = new Date(&apos;1/10/2007&apos;);
		/// document.write(Date.dayNames[dt.getFirstDayOfMonth()]); //output: &apos;Monday&apos;
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\util\Date.js</definedin>
		/// <returns>The day number (0-6).</returns>
		[ScriptName("getFirstDayOfMonth")]
		public System.Number GetFirstDayOfMonth()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Get the last day of the current month, adjusted for leap year. The returned value
		/// is the numeric day index within the week (0-6) which can be used in conjunction with
		/// the {@link #monthNames} array to retrieve the textual day name.
		/// Example:
		/// 
		/// var dt = new Date(&apos;1/10/2007&apos;);
		/// document.write(Date.dayNames[dt.getLastDayOfMonth()]); //output: &apos;Wednesday&apos;
		/// </summary>
		/// <htmlSummary>
		/// Get the last day of the current month, adjusted for leap year. The returned value
		/// is the numeric day index within the week (0-6) which can be used in conjunction with
		/// the {@link #monthNames} array to retrieve the textual day name.
		/// Example:
		/// &lt;pre&gt;&lt;code&gt;
		/// var dt = new Date(&apos;1/10/2007&apos;);
		/// document.write(Date.dayNames[dt.getLastDayOfMonth()]); //output: &apos;Wednesday&apos;
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\util\Date.js</definedin>
		/// <returns>The day number (0-6).</returns>
		[ScriptName("getLastDayOfMonth")]
		public System.Number GetLastDayOfMonth()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Get the date of the first day of the month in which this date resides.</summary>
		/// <definedin>src\util\Date.js</definedin>
		[ScriptName("getFirstDateOfMonth")]
		public System.DateTime GetFirstDateOfMonth()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Get the date of the last day of the month in which this date resides.</summary>
		/// <definedin>src\util\Date.js</definedin>
		[ScriptName("getLastDateOfMonth")]
		public System.DateTime GetLastDateOfMonth()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Get the number of days in the current month, adjusted for leap year.</summary>
		/// <definedin>src\util\Date.js</definedin>
		/// <returns>The number of days in the month.</returns>
		[ScriptName("getDaysInMonth")]
		public System.Number GetDaysInMonth()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Get the English ordinal suffix of the current day (equivalent to the format specifier &apos;S&apos;).</summary>
		/// <definedin>src\util\Date.js</definedin>
		/// <returns>&apos;st, &apos;nd&apos;, &apos;rd&apos; or &apos;th&apos;.</returns>
		[ScriptName("getSuffix")]
		public string GetSuffix()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Creates and returns a new Date instance with the exact same date value as the called instance.
		/// Dates are copied and passed by reference, so if a copied date variable is modified later, the original
		/// variable will also be changed. When the intention is to create a new variable that will not
		/// modify the original instance, you should create a clone.
		///
		/// Example of correctly cloning a date:
		/// 
		/// //wrong way:
		/// var orig = new Date(&apos;10/1/2006&apos;);
		/// var copy = orig;
		/// copy.setDate(5);
		/// document.write(orig); //returns &apos;Thu Oct 05 2006&apos;!
		///
		/// //correct way:
		/// var orig = new Date(&apos;10/1/2006&apos;);
		/// var copy = orig.clone();
		/// copy.setDate(5);
		/// document.write(orig); //returns &apos;Thu Oct 01 2006&apos;
		/// </summary>
		/// <htmlSummary>
		/// Creates and returns a new Date instance with the exact same date value as the called instance.
		/// Dates are copied and passed by reference, so if a copied date variable is modified later, the original
		/// variable will also be changed. When the intention is to create a new variable that will not
		/// modify the original instance, you should create a clone.
		///
		/// Example of correctly cloning a date:
		/// &lt;pre&gt;&lt;code&gt;
		/// //wrong way:
		/// var orig = new Date(&apos;10/1/2006&apos;);
		/// var copy = orig;
		/// copy.setDate(5);
		/// document.write(orig); //returns &apos;Thu Oct 05 2006&apos;!
		///
		/// //correct way:
		/// var orig = new Date(&apos;10/1/2006&apos;);
		/// var copy = orig.clone();
		/// copy.setDate(5);
		/// document.write(orig); //returns &apos;Thu Oct 01 2006&apos;
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\util\Date.js</definedin>
		/// <returns>The new Date instance.</returns>
		[ScriptName("clone")]
		public System.DateTime Clone()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Checks if the current date is affected by Daylight Saving Time (DST).</summary>
		/// <definedin>src\util\Date.js</definedin>
		/// <returns>True if the current date is affected by DST.</returns>
		[ScriptName("isDST")]
		public bool IsDST()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Attempts to clear all time information from this Date by setting the time to midnight of the same day,
		/// automatically adjusting for Daylight Saving Time (DST) where applicable.
		/// (note: DST timezone information for the browser&apos;s host operating system is assumed to be up-to-date)
		/// </summary>
		/// <definedin>src\util\Date.js</definedin>
		/// <param name="clone">true to create a clone of this date, clear the time and return it (defaults to false).</param>
		/// <returns>this or the clone.</returns>
		[ScriptName("clearTime")]
		public System.DateTime ClearTime(bool clone)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Provides a convenient method for performing basic date arithmetic. This method
		/// does not modify the Date instance being called - it creates and returns
		/// a new Date instance containing the resulting date value.
		///
		/// Examples:
		/// 
		/// // Basic usage:
		/// var dt = new Date(&apos;10/29/2006&apos;).add(Date.DAY, 5);
		/// document.write(dt); //returns &apos;Fri Nov 03 2006 00:00:00&apos;
		///
		/// // Negative values will be subtracted:
		/// var dt2 = new Date(&apos;10/1/2006&apos;).add(Date.DAY, -5);
		/// document.write(dt2); //returns &apos;Tue Sep 26 2006 00:00:00&apos;
		///
		/// // You can even chain several calls together in one line:
		/// var dt3 = new Date(&apos;10/1/2006&apos;).add(Date.DAY, 5).add(Date.HOUR, 8).add(Date.MINUTE, -30);
		/// document.write(dt3); //returns &apos;Fri Oct 06 2006 07:30:00&apos;
		/// </summary>
		/// <htmlSummary>
		/// Provides a convenient method for performing basic date arithmetic. This method
		/// does not modify the Date instance being called - it creates and returns
		/// a new Date instance containing the resulting date value.
		///
		/// Examples:
		/// &lt;pre&gt;&lt;code&gt;
		/// // Basic usage:
		/// var dt = new Date(&apos;10/29/2006&apos;).add(Date.DAY, 5);
		/// document.write(dt); //returns &apos;Fri Nov 03 2006 00:00:00&apos;
		///
		/// // Negative values will be subtracted:
		/// var dt2 = new Date(&apos;10/1/2006&apos;).add(Date.DAY, -5);
		/// document.write(dt2); //returns &apos;Tue Sep 26 2006 00:00:00&apos;
		///
		/// // You can even chain several calls together in one line:
		/// var dt3 = new Date(&apos;10/1/2006&apos;).add(Date.DAY, 5).add(Date.HOUR, 8).add(Date.MINUTE, -30);
		/// document.write(dt3); //returns &apos;Fri Oct 06 2006 07:30:00&apos;
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\util\Date.js</definedin>
		/// <param name="interval">A valid date interval enum value.</param>
		/// <param name="value">The amount to add to the current date.</param>
		/// <returns>The new Date instance.</returns>
		[ScriptName("add")]
		public System.DateTime Add(string interval, System.Number value)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Checks if this date falls on or between the given start and end dates.</summary>
		/// <definedin>src\util\Date.js</definedin>
		/// <param name="start">Start date</param>
		/// <param name="end">End date</param>
		/// <returns>true if this date falls on or between the given start and end dates.</returns>
		[ScriptName("between")]
		public bool Between(System.DateTime start, System.DateTime end)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Formats a date given the supplied format string.</summary>
		/// <definedin>src\util\Date.js</definedin>
		/// <param name="format">The format string.</param>
		/// <returns>The formatted date.</returns>
		[ScriptName("format")]
		public string Format(string format)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns the number of milliseconds between this date and date</summary>
		/// <definedin>src\core\Ext-more.js</definedin>
		/// <param name="date">Defaults to now</param>
		/// <returns>The diff in milliseconds</returns>
		[ScriptName("getElapsed")]
		public System.Number GetElapsed(System.DateTime date)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns the number of milliseconds between this date and date</summary>
		/// <definedin>src\core\Ext-more.js</definedin>
		/// <returns>The diff in milliseconds</returns>
		[ScriptName("getElapsed")]
		public System.Number GetElapsed()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Checks if the passed Date parameters will cause a javascript Date &quot;rollover&quot;.</summary>
		/// <definedin>src\util\Date.js</definedin>
		/// <param name="year">4-digit year</param>
		/// <param name="month">1-based month-of-year</param>
		/// <param name="day">Day of month</param>
		/// <param name="hour">Hour</param>
		/// <param name="minute">Minute</param>
		/// <param name="second">Second</param>
		/// <param name="millisecond">Millisecond</param>
		/// <returns>true if the passed parameters do not cause a Date &quot;rollover&quot;, false otherwise.</returns>
		[ScriptName("isValid")]
		public static bool IsValid(System.Number year, System.Number month, System.Number day, System.Number hour, System.Number minute, System.Number second, System.Number millisecond)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Checks if the passed Date parameters will cause a javascript Date &quot;rollover&quot;.</summary>
		/// <definedin>src\util\Date.js</definedin>
		/// <param name="year">4-digit year</param>
		/// <param name="month">1-based month-of-year</param>
		/// <param name="day">Day of month</param>
		/// <param name="hour">Hour</param>
		/// <param name="minute">Minute</param>
		/// <param name="second">Second</param>
		/// <returns>true if the passed parameters do not cause a Date &quot;rollover&quot;, false otherwise.</returns>
		[ScriptName("isValid")]
		public static bool IsValid(System.Number year, System.Number month, System.Number day, System.Number hour, System.Number minute, System.Number second)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Checks if the passed Date parameters will cause a javascript Date &quot;rollover&quot;.</summary>
		/// <definedin>src\util\Date.js</definedin>
		/// <param name="year">4-digit year</param>
		/// <param name="month">1-based month-of-year</param>
		/// <param name="day">Day of month</param>
		/// <param name="hour">Hour</param>
		/// <param name="minute">Minute</param>
		/// <returns>true if the passed parameters do not cause a Date &quot;rollover&quot;, false otherwise.</returns>
		[ScriptName("isValid")]
		public static bool IsValid(System.Number year, System.Number month, System.Number day, System.Number hour, System.Number minute)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Checks if the passed Date parameters will cause a javascript Date &quot;rollover&quot;.</summary>
		/// <definedin>src\util\Date.js</definedin>
		/// <param name="year">4-digit year</param>
		/// <param name="month">1-based month-of-year</param>
		/// <param name="day">Day of month</param>
		/// <param name="hour">Hour</param>
		/// <returns>true if the passed parameters do not cause a Date &quot;rollover&quot;, false otherwise.</returns>
		[ScriptName("isValid")]
		public static bool IsValid(System.Number year, System.Number month, System.Number day, System.Number hour)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Checks if the passed Date parameters will cause a javascript Date &quot;rollover&quot;.</summary>
		/// <definedin>src\util\Date.js</definedin>
		/// <param name="year">4-digit year</param>
		/// <param name="month">1-based month-of-year</param>
		/// <param name="day">Day of month</param>
		/// <returns>true if the passed parameters do not cause a Date &quot;rollover&quot;, false otherwise.</returns>
		[ScriptName("isValid")]
		public static bool IsValid(System.Number year, System.Number month, System.Number day)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Parses the passed string using the specified date format.
		/// Note that this function expects normal calendar dates, meaning that months are 1-based (i.e. 1 = January).
		/// The {@link #defaults} hash will be used for any date value (i.e. year, month, day, hour, minute, second or millisecond)
		/// which cannot be found in the passed string. If a corresponding default date value has not been specified in the {@link #defaults} hash,
		/// the current date&apos;s year, month, day or DST-adjusted zero-hour time value will be used instead.
		/// Keep in mind that the input date string must precisely match the specified format string
		/// in order for the parse operation to be successful (failed parse operations return a null value).
		/// Example:  
		/// //dt = Fri May 25 2007 (current date)
		/// var dt = new Date();
		///
		/// //dt = Thu May 25 2006 (today&apos;s month/day in 2006)
		/// dt = Date.parseDate(&quot;2006&quot;, &quot;Y&quot;);
		///
		/// //dt = Sun Jan 15 2006 (all date parts specified)
		/// dt = Date.parseDate(&quot;2006-01-15&quot;, &quot;Y-m-d&quot;);
		///
		/// //dt = Sun Jan 15 2006...
		/// </summary>
		/// <htmlSummary>
		/// Parses the passed string using the specified date format.
		/// Note that this function expects normal calendar dates, meaning that months are 1-based (i.e. 1 = January).
		/// The {@link #defaults} hash will be used for any date value (i.e. year, month, day, hour, minute, second or millisecond)
		/// which cannot be found in the passed string. If a corresponding default date value has not been specified in the {@link #defaults} hash,
		/// the current date&apos;s year, month, day or DST-adjusted zero-hour time value will be used instead.
		/// Keep in mind that the input date string must precisely match the specified format string
		/// in order for the parse operation to be successful (failed parse operations return a null value).
		/// &lt;p&gt;Example:&lt;/p&gt;&lt;pre&gt;&lt;code&gt;
		/// //dt = Fri May 25 2007 (current date)
		/// var dt = new Date();
		///
		/// //dt = Thu May 25 2006 (today&amp;#39;s month/day in 2006)
		/// dt = Date.parseDate(&quot;2006&quot;, &quot;Y&quot;);
		///
		/// //dt = Sun Jan 15 2006 (all date parts specified)
		/// dt = Date.parseDate(&quot;2006-01-15&quot;, &quot;Y-m-d&quot;);
		///
		/// //dt = Sun Jan 15 2006 15:20:01
		/// dt = Date.parseDate(&quot;2006-01-15 3:20:01 PM&quot;, &quot;Y-m-d g:i:s A&quot;);
		///
		/// // attempt to parse Sun Feb 29 2006 03:20:01 in strict mode
		/// dt = Date.parseDate(&quot;2006-02-29 03:20:01&quot;, &quot;Y-m-d H:i:s&quot;, true); // returns null
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\util\Date.js</definedin>
		/// <param name="input">The raw date string.</param>
		/// <param name="format">The expected date string format.</param>
		/// <param name="strict">
		/// True to validate date strings while parsing (i.e. prevents javascript Date &quot;rollover&quot;)
		/// (defaults to false). Invalid date strings will return null when parsed.
		/// </param>
		/// <returns>The parsed Date.</returns>
		[ScriptName("parseDate")]
		public static System.DateTime ParseDate(string input, string format, bool strict)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Parses the passed string using the specified date format.
		/// Note that this function expects normal calendar dates, meaning that months are 1-based (i.e. 1 = January).
		/// The {@link #defaults} hash will be used for any date value (i.e. year, month, day, hour, minute, second or millisecond)
		/// which cannot be found in the passed string. If a corresponding default date value has not been specified in the {@link #defaults} hash,
		/// the current date&apos;s year, month, day or DST-adjusted zero-hour time value will be used instead.
		/// Keep in mind that the input date string must precisely match the specified format string
		/// in order for the parse operation to be successful (failed parse operations return a null value).
		/// Example:  
		/// //dt = Fri May 25 2007 (current date)
		/// var dt = new Date();
		///
		/// //dt = Thu May 25 2006 (today&apos;s month/day in 2006)
		/// dt = Date.parseDate(&quot;2006&quot;, &quot;Y&quot;);
		///
		/// //dt = Sun Jan 15 2006 (all date parts specified)
		/// dt = Date.parseDate(&quot;2006-01-15&quot;, &quot;Y-m-d&quot;);
		///
		/// //dt = Sun Jan 15 2006...
		/// </summary>
		/// <htmlSummary>
		/// Parses the passed string using the specified date format.
		/// Note that this function expects normal calendar dates, meaning that months are 1-based (i.e. 1 = January).
		/// The {@link #defaults} hash will be used for any date value (i.e. year, month, day, hour, minute, second or millisecond)
		/// which cannot be found in the passed string. If a corresponding default date value has not been specified in the {@link #defaults} hash,
		/// the current date&apos;s year, month, day or DST-adjusted zero-hour time value will be used instead.
		/// Keep in mind that the input date string must precisely match the specified format string
		/// in order for the parse operation to be successful (failed parse operations return a null value).
		/// &lt;p&gt;Example:&lt;/p&gt;&lt;pre&gt;&lt;code&gt;
		/// //dt = Fri May 25 2007 (current date)
		/// var dt = new Date();
		///
		/// //dt = Thu May 25 2006 (today&amp;#39;s month/day in 2006)
		/// dt = Date.parseDate(&quot;2006&quot;, &quot;Y&quot;);
		///
		/// //dt = Sun Jan 15 2006 (all date parts specified)
		/// dt = Date.parseDate(&quot;2006-01-15&quot;, &quot;Y-m-d&quot;);
		///
		/// //dt = Sun Jan 15 2006 15:20:01
		/// dt = Date.parseDate(&quot;2006-01-15 3:20:01 PM&quot;, &quot;Y-m-d g:i:s A&quot;);
		///
		/// // attempt to parse Sun Feb 29 2006 03:20:01 in strict mode
		/// dt = Date.parseDate(&quot;2006-02-29 03:20:01&quot;, &quot;Y-m-d H:i:s&quot;, true); // returns null
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\util\Date.js</definedin>
		/// <param name="input">The raw date string.</param>
		/// <param name="format">The expected date string format.</param>
		/// <returns>The parsed Date.</returns>
		[ScriptName("parseDate")]
		public static System.DateTime ParseDate(string input, string format)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Get the offset from GMT of the current date (equivalent to the format specifier &apos;O&apos;).</summary>
		/// <definedin>src\util\Date.js</definedin>
		/// <param name="colon">true to separate the hours and minutes with a colon (defaults to false).</param>
		/// <returns>The 4-character offset string prefixed with + or - (e.g. &apos;-0600&apos;).</returns>
		[ScriptName("getGMTOffset")]
		public string GetGMTOffset(bool colon)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Get the offset from GMT of the current date (equivalent to the format specifier &apos;O&apos;).</summary>
		/// <definedin>src\util\Date.js</definedin>
		/// <returns>The 4-character offset string prefixed with + or - (e.g. &apos;-0600&apos;).</returns>
		[ScriptName("getGMTOffset")]
		public string GetGMTOffset()
		{
			throw new System.Exception("Imported - not implemented");
		}
		#endregion
	}
}
